// $ANTLR : "analizador.g" -> "Anasint.java"$

/* codigo de cabecera */

import antlr.TokenBuffer;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.ANTLRException;
import antlr.LLkParser;
import antlr.Token;
import antlr.TokenStream;
import antlr.RecognitionException;
import antlr.NoViableAltException;
import antlr.MismatchedTokenException;
import antlr.SemanticException;
import antlr.ParserSharedInputState;
import antlr.collections.impl.BitSet;

public class Anasint extends antlr.LLkParser       implements AnalexTokenTypes
 {

protected Anasint(TokenBuffer tokenBuf, int k) {
  super(tokenBuf,k);
  tokenNames = _tokenNames;
}

public Anasint(TokenBuffer tokenBuf) {
  this(tokenBuf,1);
}

protected Anasint(TokenStream lexer, int k) {
  super(lexer,k);
  tokenNames = _tokenNames;
}

public Anasint(TokenStream lexer) {
  this(lexer,1);
}

public Anasint(ParserSharedInputState state) {
  super(state,1);
  tokenNames = _tokenNames;
}

	public final void entrada() throws RecognitionException, TokenStreamException {
		
		
		{
		_loop71:
		do {
			if ((LA(1)==IDENT)) {
				unidades();
			}
			else {
				break _loop71;
			}
			
		} while (true);
		}
		{
		declaraciones();
		}
		{
		reglas();
		}
		{
		codigo();
		}
		match(Token.EOF_TYPE);
	}
	
	public final void unidades() throws RecognitionException, TokenStreamException {
		
		
		match(IDENT);
		match(DEF_CHAR);
	}
	
	public final void declaraciones() throws RecognitionException, TokenStreamException {
		
		
		match(ABRIR);
		{
		_loop80:
		do {
			if ((LA(1)==INT||LA(1)==CHAR)) {
				tipo();
				match(IDENT);
				match(SEPARADOR);
			}
			else {
				break _loop80;
			}
			
		} while (true);
		}
		match(CERRAR);
	}
	
	public final void reglas() throws RecognitionException, TokenStreamException {
		
		
		match(REGLA);
		{
		_loop83:
		do {
			if ((LA(1)==IDENT||LA(1)==PARENTESIS_ABIERTO||LA(1)==LLAVE_ABIERTA)) {
				regla();
			}
			else {
				break _loop83;
			}
			
		} while (true);
		}
		match(REGLA);
	}
	
	public final void codigo() throws RecognitionException, TokenStreamException {
		
		
		{
		_loop98:
		do {
			if ((LA(1)==INT||LA(1)==CHAR)) {
				funcion();
			}
			else {
				break _loop98;
			}
			
		} while (true);
		}
	}
	
	public final void tipo() throws RecognitionException, TokenStreamException {
		
		
		{
		switch ( LA(1)) {
		case CHAR:
		{
			match(CHAR);
			break;
		}
		case INT:
		{
			match(INT);
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
	}
	
	public final void regla() throws RecognitionException, TokenStreamException {
		
		
		operador();
		{
		_loop86:
		do {
			if ((LA(1)==BARRA)) {
				match(BARRA);
				operador();
			}
			else {
				break _loop86;
			}
			
		} while (true);
		}
	}
	
	public final void operador() throws RecognitionException, TokenStreamException {
		
		
		factor();
		{
		_loop89:
		do {
			if ((LA(1)==OPERADOR)) {
				match(OPERADOR);
			}
			else {
				break _loop89;
			}
			
		} while (true);
		}
	}
	
	public final void factor() throws RecognitionException, TokenStreamException {
		
		
		switch ( LA(1)) {
		case PARENTESIS_ABIERTO:
		{
			{
			match(PARENTESIS_ABIERTO);
			regla();
			match(PARENTESIS_CERRADO);
			}
			break;
		}
		case LLAVE_ABIERTA:
		{
			{
			match(LLAVE_ABIERTA);
			match(IDENT);
			match(LLAVE_CERRADA);
			}
			break;
		}
		case IDENT:
		{
			incremento();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
	}
	
	public final void incremento() throws RecognitionException, TokenStreamException {
		
		
		match(IDENT);
		{
		_loop95:
		do {
			if ((LA(1)==OPERADOR)) {
				match(OPERADOR);
			}
			else {
				break _loop95;
			}
			
		} while (true);
		}
		match(SEPARADOR);
	}
	
	public final void funcion() throws RecognitionException, TokenStreamException {
		
		
		tipo();
		match(IDENT);
		match(PARENTESIS_ABIERTO);
		{
		switch ( LA(1)) {
		case INT:
		case CHAR:
		{
			def_parametros();
			break;
		}
		case VOID:
		{
			match(VOID);
			break;
		}
		case PARENTESIS_CERRADO:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		match(PARENTESIS_CERRADO);
		match(LLAVE_ABIERTA);
		{
		_loop102:
		do {
			if ((_tokenSet_0.member(LA(1)))) {
				sentencia();
			}
			else {
				break _loop102;
			}
			
		} while (true);
		}
		{
		switch ( LA(1)) {
		case RETURN:
		{
			salida();
			break;
		}
		case LLAVE_CERRADA:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		match(LLAVE_CERRADA);
	}
	
	public final void def_parametros() throws RecognitionException, TokenStreamException {
		
		
		def_parametro();
		{
		_loop106:
		do {
			if ((LA(1)==COMA)) {
				match(COMA);
				def_parametro();
			}
			else {
				break _loop106;
			}
			
		} while (true);
		}
	}
	
	public final void sentencia() throws RecognitionException, TokenStreamException {
		
		
		parametro();
		{
		switch ( LA(1)) {
		case PARENTESIS_ABIERTO:
		case ASIGNACION:
		{
			tipo_sentencia();
			break;
		}
		case SEPARADOR:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		match(SEPARADOR);
	}
	
	public final void salida() throws RecognitionException, TokenStreamException {
		
		
		match(RETURN);
		match(LIT_ENTERO);
		match(SEPARADOR);
	}
	
	public final void def_parametro() throws RecognitionException, TokenStreamException {
		
		
		tipo();
		{
		switch ( LA(1)) {
		case OPERADOR:
		{
			match(OPERADOR);
			break;
		}
		case IDENT:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		match(IDENT);
		{
		switch ( LA(1)) {
		case COCH_ABIERTO:
		{
			match(COCH_ABIERTO);
			match(COCH_CERRADO);
			break;
		}
		case PARENTESIS_CERRADO:
		case COMA:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
	}
	
	public final void parametro() throws RecognitionException, TokenStreamException {
		
		
		switch ( LA(1)) {
		case IDENT:
		{
			match(IDENT);
			{
			switch ( LA(1)) {
			case COCH_ABIERTO:
			{
				match(COCH_ABIERTO);
				match(LIT_ENTERO);
				match(COCH_CERRADO);
				break;
			}
			case PARENTESIS_ABIERTO:
			case PARENTESIS_CERRADO:
			case SEPARADOR:
			case COMA:
			case ASIGNACION:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			break;
		}
		case LIT_ENTERO:
		{
			match(LIT_ENTERO);
			break;
		}
		case LIT_REAL:
		{
			match(LIT_REAL);
			break;
		}
		case CADENA:
		{
			match(CADENA);
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
	}
	
	public final void tipo_sentencia() throws RecognitionException, TokenStreamException {
		
		
		switch ( LA(1)) {
		case ASIGNACION:
		{
			asignacion();
			break;
		}
		case PARENTESIS_ABIERTO:
		{
			llamada();
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
	}
	
	public final void asignacion() throws RecognitionException, TokenStreamException {
		
		
		match(ASIGNACION);
		parametro();
		{
		switch ( LA(1)) {
		case PARENTESIS_ABIERTO:
		case ASIGNACION:
		{
			tipo_sentencia();
			break;
		}
		case SEPARADOR:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
	}
	
	public final void llamada() throws RecognitionException, TokenStreamException {
		
		
		match(PARENTESIS_ABIERTO);
		{
		switch ( LA(1)) {
		case LIT_REAL:
		case LIT_ENTERO:
		case IDENT:
		case CADENA:
		{
			parametros();
			break;
		}
		case PARENTESIS_CERRADO:
		{
			break;
		}
		default:
		{
			throw new NoViableAltException(LT(1), getFilename());
		}
		}
		}
		match(PARENTESIS_CERRADO);
	}
	
	public final void parametros() throws RecognitionException, TokenStreamException {
		
		
		parametro();
		{
		_loop120:
		do {
			if ((LA(1)==COMA)) {
				match(COMA);
				parametro();
			}
			else {
				break _loop120;
			}
			
		} while (true);
		}
	}
	
	
	public static final String[] _tokenNames = {
		"<0>",
		"EOF",
		"<2>",
		"NULL_TREE_LOOKAHEAD",
		"LIT_REAL",
		"LIT_ENTERO",
		"\"int\"",
		"\"void\"",
		"\"char\"",
		"\"while\"",
		"\"if\"",
		"\"return\"",
		"TAB",
		"NUEVA_LINEA",
		"COMENTARIO",
		"BLANCO",
		"DIGITO",
		"NUMERO",
		"LETRA",
		"IDENT",
		"OPERADOR",
		"PARENTESIS_ABIERTO",
		"PARENTESIS_CERRADO",
		"LLAVE_ABIERTA",
		"LLAVE_CERRADA",
		"COCH_ABIERTO",
		"COCH_CERRADO",
		"DEF_CHAR",
		"ABRIR",
		"CERRAR",
		"SEPARADOR",
		"REGLA",
		"BARRA",
		"COMA",
		"ASIGNACION",
		"CADENA",
		"PORCENTAJE",
		"AMPERSAN",
		"IGUAL",
		"MENOR_QUE",
		"MAYOR_QUE",
		"MAYOR_IGUAL",
		"MENOR_IGUAL",
		"PUNTO"
	};
	
	private static final long[] mk_tokenSet_0() {
		long[] data = { 34360262704L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
	
	}
